// pages/carpoolAdd/carpoolAdd.js
const api = require("../../config/api.js");
const util = require("../../utils/util.js");
const shareCard = require("../../utils/shareCard.js");

Page({
  /**
   * 页面的初始数据
   */
  data: {
    formData: {
      date: '', // 日期
      goTime: '', // 出发时间
      fromAddr: '', // 出发地点
      toAddr: '', // 到达地点
      fromAddrId: '', // 出发地点雪场ID
      toAddrId: '', // 到达地点雪场ID
      fromLongitude: null, // 出发地点经度
      fromLatitude: null, // 出发地点纬度
      fromLocationName: '', // 出发地点地址
      toLongitude: null, // 到达地点经度
      toLatitude: null, // 到达地点纬度
      toLocationName: '', // 到达地点地址
      people: 0, // 可拼人数
      ski: 0, // 雪板数量
      bag: 0, // 板包数量
      price: '', // 拼车费用
      detail: '', // 详细信息
      wechat: '', // 微信
      phone: '', // 电话
      side: 0, // 0:前往 1:返回
      type: 0 // 0:车找人 1:人找车
    },
    // 日期选择器相关
    showDatePicker: false,
    currentDate: new Date().getTime(),
    minDate: new Date().getTime(),
    maxDate: new Date(new Date().getTime() + 365 * 24 * 60 * 60 * 1000).getTime(), // 一年后
    // 时间选择器相关
    showTimePicker: false,
    currentTime: '12:00',
    minHour: 0,
    maxHour: 23,
    // 时间选择器格式化函数（添加"时"、"分"单位）
    timeFormatter: function(type, value) {
      if (type === 'hour') {
        return `${value}时`
      }
      if (type === 'minute') {
        return `${value}分`
      }
      return value
    },
    // 时间选择器过滤函数（分钟改为10分钟间隔）
    timeFilter: function(type, values) {
      if (type === 'minute') {
        // 只返回10分钟间隔的选项：0, 10, 20, 30, 40, 50
        return values.filter(value => value % 10 === 0)
      }
      return values
    },
    // 地点选择器相关
    currentLocationType: null, // 当前选择的位置类型：'departure' 或 'destination'
    // 雪场列表（保留用于其他用途）
    skiList: [],
    // SkiDropdown组件相关
    skiDropdownOpen: false,
    skiDropdownTop: 0,
    selectedSkiId: null, // 当前选中的雪场ID，用于回显和传递给组件
    // 成功弹窗相关
    showSuccessPopup: false,
    // 编辑模式相关
    editId: null,
    isEditMode: false,
    // 用户信息
    currentUserInfo: null,
    // 是否已加入俱乐部
    isClubMember: false,
    // 提交按钮文案
    submitButtonText: '提交',
    // 发布成功后返回的ID
    publishedId: null,
    // 分享卡片图片路径
    shareCardImageUrl: null
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad: function (options) {
    console.log('拼车信息新增页面加载完成', options)
    
    // 处理从home页面传递的参数
    if (options.side !== undefined) {
      this.setData({
        'formData.side': parseInt(options.side)
      })
    }
    
    if (options.type !== undefined) {
      this.setData({
        'formData.type': parseInt(options.type)
      })
    }
    
    // 不再需要加载公共信息，SkiDropdown组件内部会处理数据加载
    
    // 获取用户信息
    this.loadUserInfo()
    
    // 处理编辑模式 - 如果有id参数，则获取详情数据回显
    if (options.id) {
      this.setData({
        editId: options.id,
        isEditMode: true,
        submitButtonText: '更新'
      })
      // 设置页面标题为"编辑拼车"
      wx.setNavigationBarTitle({
        title: '编辑拼车'
      })
      this.loadCarpoolDetail(options.id)
    } 
    // 处理再发一单模式 - 如果有copyId参数，则加载数据并回填（但不设置编辑模式）
    else if (options.copyId) {
      // 设置页面标题为"发布拼车"
      wx.setNavigationBarTitle({
        title: '发布拼车'
      })
      // 加载数据并回填，但不设置编辑模式
      this.loadCarpoolDetailForCopy(options.copyId)
    } 
    else {
      // 设置页面标题为"发布拼车"
      wx.setNavigationBarTitle({
        title: '发布拼车'
      })
    }
  },


  /**
   * 加载用户信息
   */
  loadUserInfo: function() {
    // 从本地存储获取用户信息
    const userInfo = wx.getStorageSync('userInfo')
    const token = wx.getStorageSync('token')
    
    if (userInfo && token) {
      // 判断是否已加入俱乐部
      const isClubMember = userInfo.isClub === 1;
      
      this.setData({
        currentUserInfo: userInfo,
        isClubMember: isClubMember
      })
      
      console.log('用户信息加载成功:', userInfo)
      console.log('是否已加入俱乐部:', isClubMember)
    } else {
      this.setData({
        currentUserInfo: null,
        isClubMember: false
      })
    }
  },

  /**
   * 返回按钮
   */
  goBack: function() {
    wx.navigateBack()
  },

  /**
   * 加载拼车详情数据
   */
  loadCarpoolDetail: function(id) {
    const api = require('../../config/api.js')
    const util = require('../../utils/util.js')
    
    wx.showLoading({
      title: '加载中...',
      mask: true
    })
    
    console.log('调用拼车详情接口，参数 id:', id)
    console.log('接口地址:', api.CarInfo)
    
    util.request(api.CarInfo, {
      id: id
    }, 'POST', 'application/json').then(res => {
      console.log('拼车详情响应:', res)
      
      const normalizedRes = util.normalizeApiResponse(res)
      
      if (normalizedRes.success && normalizedRes.data) {
        const detailData = normalizedRes.data
        
        // 格式化日期的辅助函数
        const formatDate = (timestamp) => {
          if (!timestamp) return ''
          try {
            // 判断是否为时间戳（数字）
            const date = typeof timestamp === 'number' 
              ? new Date(timestamp) 
              : new Date(timestamp)
            
            if (!isNaN(date.getTime())) {
              const year = date.getFullYear()
              const month = String(date.getMonth() + 1).padStart(2, '0')
              const day = String(date.getDate()).padStart(2, '0')
              return `${year}-${month}-${day}`
            }
          } catch (error) {
            console.log('解析日期失败:', error)
          }
          return ''
        }
        
        // 格式化时间戳为日期字符串
        const formattedDate = formatDate(detailData.date)
        const dateTimeStamp = detailData.date ? (typeof detailData.date === 'number' ? detailData.date : new Date(detailData.date).getTime()) : new Date().getTime()
        
        // 回显数据到表单
        // 注意：price 和 phone 需要保持数字类型或字符串类型显示
        // 根据side判断地图选点信息属于哪个地点
        // side=0 (前往): 出发地点用地图，longitude/latitude/locationName 属于出发地点
        // side=1 (返回): 到达地点用地图，longitude/latitude/locationName 属于到达地点
        this.setData({
          'formData.date': formattedDate,
          'formData.goTime': detailData.goTime || '',
          'formData.fromAddr': detailData.fromAddr || '',
          'formData.toAddr': detailData.toAddr || '',
          'formData.fromAddrId': detailData.fromAddrId || '',
          'formData.toAddrId': detailData.toAddrId || '',
          'formData.fromLongitude': (detailData.side === 0 && detailData.longitude) ? detailData.longitude : null,
          'formData.fromLatitude': (detailData.side === 0 && detailData.latitude) ? detailData.latitude : null,
          'formData.fromLocationName': (detailData.side === 0 && detailData.locationName) ? detailData.locationName : '',
          'formData.toLongitude': (detailData.side === 1 && detailData.longitude) ? detailData.longitude : null,
          'formData.toLatitude': (detailData.side === 1 && detailData.latitude) ? detailData.latitude : null,
          'formData.toLocationName': (detailData.side === 1 && detailData.locationName) ? detailData.locationName : '',
          'formData.people': detailData.people || 0,
          'formData.ski': detailData.ski || 0,
          'formData.bag': detailData.bag || 0,
          'formData.price': detailData.price ? String(detailData.price) : '',
          'formData.detail': detailData.detail || '',
          'formData.wechat': detailData.wechat || '',
          'formData.phone': detailData.phone ? String(detailData.phone) : '',
          'formData.side': detailData.side || 0,
          'formData.type': detailData.type || 0,
          currentDate: dateTimeStamp,
          currentTime: detailData.goTime || this.getCurrentTime(),
          // 设置selectedSkiId用于SkiDropdown回显（如果编辑时选择了出发地或目的地）
          selectedSkiId: detailData.fromAddrId || detailData.toAddrId || null
        })
        
        wx.hideLoading()
      } else {
        wx.showToast({
          title: normalizedRes.message || '加载详情失败',
          icon: 'none'
        })
        wx.hideLoading()
      }
    }).catch(err => {
      console.error('加载拼车详情失败:', err)
      wx.showToast({
        title: '网络错误，请重试',
        icon: 'none'
      })
      wx.hideLoading()
    })
  },

  /**
   * 加载拼车详情数据用于再发一单（回填部分数据）
   */
  loadCarpoolDetailForCopy: function(id) {
    const api = require('../../config/api.js')
    const util = require('../../utils/util.js')
    
    wx.showLoading({
      title: '加载中...',
      mask: true
    })
    
    console.log('调用拼车详情接口（再发一单），参数 id:', id)
    
    util.request(api.CarInfo, {
      id: id
    }, 'POST', 'application/json').then(res => {
      console.log('拼车详情响应（再发一单）:', res)
      
      const normalizedRes = util.normalizeApiResponse(res)
      
      if (normalizedRes.success && normalizedRes.data) {
        const detailData = normalizedRes.data
        
        // 格式化日期的辅助函数
        const formatDate = (timestamp) => {
          if (!timestamp) return ''
          try {
            const date = typeof timestamp === 'number' 
              ? new Date(timestamp) 
              : new Date(timestamp)
            
            if (!isNaN(date.getTime())) {
              const year = date.getFullYear()
              const month = String(date.getMonth() + 1).padStart(2, '0')
              const day = String(date.getDate()).padStart(2, '0')
              return `${year}-${month}-${day}`
            }
          } catch (error) {
            console.log('解析日期失败:', error)
          }
          return ''
        }
        
        // 再发一单模式：回填所有表单字段，仅不回填出发时间
        // 回填的表单字段：出发地、目的地、日期、人数、雪板、板包、类型、方向、地图坐标、价格、详情、微信号、手机号
        // 不回填的字段：出发时间(formData.goTime) - 让用户重新选择
        // 根据side判断地图选点信息属于哪个地点
        // side=0 (前往): 出发地点用地图，longitude/latitude/locationName 属于出发地点
        // side=1 (返回): 到达地点用地图，longitude/latitude/locationName 属于到达地点
        
        // 回填所有表单字段（除了出发时间）
        this.setData({
          // 表单字段：地点信息
          'formData.fromAddr': detailData.fromAddr || '',
          'formData.toAddr': detailData.toAddr || '',
          'formData.fromAddrId': detailData.fromAddrId || '',
          'formData.toAddrId': detailData.toAddrId || '',
          'formData.fromLongitude': (detailData.side === 0 && detailData.longitude) ? detailData.longitude : null,
          'formData.fromLatitude': (detailData.side === 0 && detailData.latitude) ? detailData.latitude : null,
          'formData.fromLocationName': (detailData.side === 0 && detailData.locationName) ? detailData.locationName : '',
          'formData.toLongitude': (detailData.side === 1 && detailData.longitude) ? detailData.longitude : null,
          'formData.toLatitude': (detailData.side === 1 && detailData.latitude) ? detailData.latitude : null,
          'formData.toLocationName': (detailData.side === 1 && detailData.locationName) ? detailData.locationName : '',
          // 表单字段：人数和物品
          'formData.people': detailData.people || 0,
          'formData.ski': detailData.ski || 0,
          'formData.bag': detailData.bag || 0,
          // 表单字段：类型和方向
          'formData.side': detailData.side || 0,
          'formData.type': detailData.type || 0,
          // 表单字段：价格、详情、联系方式
          'formData.price': detailData.price ? String(detailData.price) : '',
          'formData.detail': detailData.detail || '',
          'formData.wechat': detailData.wechat || '',
          'formData.phone': detailData.phone ? String(detailData.phone) : '',
          // UI状态字段（用于组件回显，不是表单字段）
          selectedSkiId: detailData.fromAddrId || detailData.toAddrId || null
        })
        
        // 注意：日期和出发时间不回填，让用户重新选择
        // formData.goTime 保持为空，用户需要重新选择出发时间
        
        console.log('再发一单：数据回填完成')
        
        wx.hideLoading()
      } else {
        wx.showToast({
          title: normalizedRes.message || '加载详情失败',
          icon: 'none'
        })
        wx.hideLoading()
      }
    }).catch(err => {
      console.error('加载拼车详情失败（再发一单）:', err)
      wx.showToast({
        title: '网络错误，请重试',
        icon: 'none'
      })
      wx.hideLoading()
    })
  },

  /**
   * 显示日期选择器
   */
  showDatePicker: function() {
    // 如果已经有选择的日期，使用已选择的日期；否则使用当前日期
    let currentDate = new Date().getTime()
    
    if (this.data.formData.date) {
      try {
        // 确保日期格式正确
        const dateStr = this.data.formData.date
        const date = new Date(dateStr)
        if (!isNaN(date.getTime())) {
          currentDate = date.getTime()
        }
      } catch (error) {
        console.log('解析已选择日期失败，使用当前日期:', error)
      }
    }
    
    console.log('显示日期选择器，当前日期:', new Date(currentDate))
    
    this.setData({
      showDatePicker: true,
      currentDate: currentDate
    })
  },

  /**
   * 显示地点选择器 - 根据往返类型选择不同的方式
   */
  showLocationPicker: function(e) {
    const type = e.currentTarget.dataset.type
    const side = this.data.formData.side // 0:前往 1:返回
    
    this.setData({
      currentLocationType: type
    })
    
    // 前往雪场（side=0）：出发地点用地图，到达地点用雪场列表
    // 雪场返回（side=1）：出发地点用雪场列表，到达地点用地图
    let isSkiResort = false
    
    if (side === 0) {
      // 前往雪场
      if (type === 'destination') {
        // 到达地点选择雪场
        isSkiResort = true
      } else {
        // 出发地点选择地图
        isSkiResort = false
      }
    } else {
      // 雪场返回
      if (type === 'departure') {
        // 出发地点选择雪场
        isSkiResort = true
      } else {
        // 到达地点选择地图
        isSkiResort = false
      }
    }
    
    if (isSkiResort) {
      // 使用雪场列表选择
      this.showSkiResortPicker(type)
    } else {
      // 使用地图选点
      this.showMapPicker(type)
    }
  },

  /**
   * 显示地图选点
   */
  showMapPicker: function(type) {
    wx.chooseLocation({
      success: (res) => {
        console.log('选择的地点信息:', res)
        const field = type === 'departure' ? 'fromAddr' : 'toAddr'
        const fieldId = type === 'departure' ? 'fromAddrId' : 'toAddrId'
        const longitudeField = type === 'departure' ? 'fromLongitude' : 'toLongitude'
        const latitudeField = type === 'departure' ? 'fromLatitude' : 'toLatitude'
        const locationNameField = type === 'departure' ? 'fromLocationName' : 'toLocationName'
        
        // fromAddr/toAddr 存储 res.name，locationName 存储 res.address
        // 注意：如果 res.name 不存在，fromAddr/toAddr 使用 res.address 作为备选（保持向后兼容）
        this.setData({
          [`formData.${field}`]: res.name || res.address || '', // fromAddr/toAddr 优先使用 res.name
          [`formData.${fieldId}`]: '', // 使用地图选择时清空雪场ID
          [`formData.${longitudeField}`]: res.longitude || null,
          [`formData.${latitudeField}`]: res.latitude || null,
          [`formData.${locationNameField}`]: res.address || '' // locationName 存储 res.address
        })
      },
      fail: (error) => {
        console.log('取消选择地点或选择失败:', error)
        // 用户取消选择时不显示错误提示
        if (error.errMsg !== 'chooseLocation:fail cancel') {
          wx.showToast({
            title: '选择地点失败',
            icon: 'none'
          })
        }
      }
    })
  },

  /**
   * 显示雪场选择器 - 使用SkiDropdown组件
   */
  showSkiResortPicker: function(type) {
    // 获取当前已选中的雪场ID（用于回显）
    const fieldId = type === 'departure' ? 'fromAddrId' : 'toAddrId'
    const selectedSkiId = this.data.formData[fieldId] || null
    
    // 获取系统信息，计算从底部出现的位置
    const systemInfo = wx.getSystemInfoSync()
    const panelHeight = 320 // SkiDropdown组件高度
    const top = systemInfo.windowHeight - panelHeight
    
    this.setData({
      skiDropdownOpen: true,
      skiDropdownTop: top,
      currentLocationType: type,
      selectedSkiId: selectedSkiId
    })
  },

  /**
   * 关闭雪场选择器
   */
  closeSkiDropdown: function() {
    this.setData({
      skiDropdownOpen: false
    })
  },

  /**
   * SkiDropdown组件change事件处理（单选模式）
   */
  onSkiDropdownChange: function(e) {
    const optionId = e.detail.value
    const optionName = e.detail.name
    const type = this.data.currentLocationType
    
    if (!type) {
      console.warn('SkiDropdown change事件缺少locationType')
      return
    }
    
    // 处理"不限"选项：optionId为null时重置（虽然showAllOption=false，但保留此逻辑以防万一）
    if (optionId === null || optionId === undefined || optionId === '') {
      const field = type === 'departure' ? 'fromAddr' : 'toAddr'
      const fieldId = type === 'departure' ? 'fromAddrId' : 'toAddrId'
      const longitudeField = type === 'departure' ? 'fromLongitude' : 'toLongitude'
      const latitudeField = type === 'departure' ? 'fromLatitude' : 'toLatitude'
      const locationNameField = type === 'departure' ? 'fromLocationName' : 'toLocationName'
      this.setData({
        [`formData.${field}`]: '',
        [`formData.${fieldId}`]: '',
        [`formData.${longitudeField}`]: null,
        [`formData.${latitudeField}`]: null,
        [`formData.${locationNameField}`]: '',
        selectedSkiId: null
      })
      console.log('清空选择的雪场:', type)
      return
    }
    
    // 根据类型填充到对应的字段
    const field = type === 'departure' ? 'fromAddr' : 'toAddr'
    const fieldId = type === 'departure' ? 'fromAddrId' : 'toAddrId'
    const longitudeField = type === 'departure' ? 'fromLongitude' : 'toLongitude'
    const latitudeField = type === 'departure' ? 'fromLatitude' : 'toLatitude'
    const locationNameField = type === 'departure' ? 'fromLocationName' : 'toLocationName'
    
    // 确保optionName存在，如果不存在则使用optionId作为默认值
    const displayName = optionName || `雪场${optionId}`
    
    // 选择雪场时，清空地图选点的经纬度和地址信息
    this.setData({
      [`formData.${field}`]: displayName,
      [`formData.${fieldId}`]: optionId,
      [`formData.${longitudeField}`]: null,
      [`formData.${latitudeField}`]: null,
      [`formData.${locationNameField}`]: '',
      selectedSkiId: optionId
    })
    
    console.log('选择的雪场:', {
      type: type,
      field: field,
      fieldId: fieldId,
      name: displayName,
      id: optionId
    })
  },

  /**
   * 输入框内容变化
   */
  onInputChange: function(e) {
    const field = e.currentTarget.dataset.field
    let value = e.detail.value
    
    // 如果是价格字段，确保输入的是有效的数字
    if (field === 'price' && value !== '') {
      // 只允许数字和小数点
      value = value.replace(/[^\d.]/g, '')
      // 确保只有一个小数点
      const parts = value.split('.')
      if (parts.length > 2) {
        value = parts[0] + '.' + parts.slice(1).join('')
      }
      // 限制最大值为999
      const numValue = parseFloat(value)
      if (!isNaN(numValue) && numValue > 999) {
        value = '999'
        wx.showToast({
          title: '拼车费用不能超过999',
          icon: 'none',
          duration: 2000
        })
      }
    }
    
    // 如果是电话字段，只允许输入数字，并限制长度为11位
    if (field === 'phone') {
      // 只允许数字，过滤掉所有非数字字符（包括中文）
      value = value.replace(/[^\d]/g, '')
      // 限制最大长度为11位
      if (value.length > 11) {
        value = value.substring(0, 11)
        wx.showToast({
          title: '手机号只能输入11位',
          icon: 'none',
          duration: 1500
        })
      }
    }
    
    // 如果是微信号字段，仅不能输入汉字，其他字符都可以输入
    if (field === 'wechat') {
      // 过滤掉汉字（Unicode范围：\u4e00-\u9fa5），其他字符都可以输入
      value = value.replace(/[\u4e00-\u9fa5]/g, '')
      // 限制最大长度为20个字符
      if (value.length > 20) {
        value = value.substring(0, 20)
        wx.showToast({
          title: '微信号最多20个字符',
          icon: 'none',
          duration: 1500
        })
      }
    }
    
    this.setData({
      [`formData.${field}`]: value
    })
  },

  /**
   * 选择方向（前往/返回）
   */
  onSideChange: function(e) {
    const side = parseInt(e.currentTarget.dataset.side)
    const currentSide = this.data.formData.side
    
    // 如果side发生变化，需要清空地点选择，因为地点类型发生了改变
    if (side !== currentSide) {
      this.setData({
        'formData.side': side,
        'formData.fromAddr': '',
        'formData.toAddr': '',
        'formData.fromAddrId': '',
        'formData.toAddrId': '',
        'formData.fromLongitude': null,
        'formData.fromLatitude': null,
        'formData.fromLocationName': '',
        'formData.toLongitude': null,
        'formData.toLatitude': null,
        'formData.toLocationName': ''
      })
    } else {
      this.setData({
        'formData.side': side
      })
    }
  },

  /**
   * 选择类型（车找人/人找车）
   */
  onTypeChange: function(e) {
    const type = parseInt(e.currentTarget.dataset.type)
    this.setData({
      'formData.type': type
    })
  },

  /**
   * 日期选择器确认
   */
  onDateConfirm: function(e) {
    console.log('日期选择器confirm事件:', e.detail)
    
    // van-calendar 单选模式下直接返回日期时间戳
    const date = new Date(e.detail)
    const dateStr = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`
    
    this.setData({
      'formData.date': dateStr,
      currentDate: e.detail,
      showDatePicker: false
    })
    
    console.log('选择的日期:', dateStr)
  },

  onDatePickerClose: function() {
    console.log('关闭日期选择器')
    this.setData({
      showDatePicker: false
    })
  },

  /**
   * 显示时间选择器
   */
  showTimePicker: function() {
    // 如果已经有选择的时间，使用已选择的时间；否则使用当前时间
    let currentTime = this.data.formData.goTime || this.getCurrentTime()
    
    this.setData({
      showTimePicker: true,
      currentTime: currentTime
    })
  },

  /**
   * 获取当前时间字符串（HH:mm格式），分钟向上取整到最近的10分钟间隔
   */
  getCurrentTime: function() {
    const now = new Date()
    let hour = now.getHours()
    let minute = now.getMinutes()
    
    // 将分钟向上取整到最近的10分钟间隔（0, 10, 20, 30, 40, 50）
    // 例如：37 -> 40, 35 -> 40, 30 -> 30, 50 -> 50, 55 -> 60（需要进位到下一小时）
    minute = Math.ceil(minute / 10) * 10
    
    // 如果分钟达到60，需要进位到下一小时
    if (minute >= 60) {
      minute = 0
      hour += 1
      // 如果小时达到24，重置为0
      if (hour >= 24) {
        hour = 0
      }
    }
    
    return `${String(hour).padStart(2, '0')}:${String(minute).padStart(2, '0')}`
  },

  /**
   * 时间选择器输入事件
   */
  onTimeInput: function(e) {
    // van-datetime-picker 的 input 事件返回选中的值
    const value = e.detail
    this.setData({
      currentTime: value
    })
  },


  /**
   * 时间选择器确认事件
   */
  onTimeConfirm: function(e) {
    // van-datetime-picker 的 confirm 事件返回选中的值
    const time = e.detail
    this.setData({
      'formData.goTime': time,
      currentTime: time,
      showTimePicker: false
    })
    console.log('选择的时间:', time)
  },

  /**
   * 关闭时间选择器
   */
  onTimePickerClose: function() {
    console.log('关闭时间选择器')
    this.setData({
      showTimePicker: false
    })
  },


  /**
   * 增加计数
   */
  incrementCount: function(e) {
    const type = e.currentTarget.dataset.type
    const fieldMap = {
      'people': 'people',
      'boards': 'ski',
      'bags': 'bag'
    }
    const field = fieldMap[type]
    if (field) {
      this.setData({
        [`formData.${field}`]: this.data.formData[field] + 1
      })
    }
  },

  /**
   * 减少计数
   */
  decrementCount: function(e) {
    const type = e.currentTarget.dataset.type
    const fieldMap = {
      'people': 'people',
      'boards': 'ski',
      'bags': 'bag'
    }
    const field = fieldMap[type]
    if (field && this.data.formData[field] > 0) {
      this.setData({
        [`formData.${field}`]: this.data.formData[field] - 1
      })
    }
  },

  /**
   * 提交表单
   */
  onSubmit: function() {
    const { formData } = this.data
    
    // 表单验证
    if (!formData.date) {
      wx.showToast({
        title: '请选择日期',
        icon: 'none'
      })
      return
    }
    
    if (!formData.goTime) {
      wx.showToast({
        title: '请选择时间',
        icon: 'none'
      })
      return
    }
    
    if (!formData.fromAddr) {
      wx.showToast({
        title: '请选择出发地点',
        icon: 'none'
      })
      return
    }
    
    if (!formData.toAddr) {
      wx.showToast({
        title: '请选择到达地点',
        icon: 'none'
      })
      return
    }
    
    if (formData.people <= 0) {
      wx.showToast({
        title: '请设置可拼人数',
        icon: 'none'
      })
      return
    }
    
    if (!formData.price || formData.price.trim() === '') {
      wx.showToast({
        title: '请输入拼车费用',
        icon: 'none'
      })
      return
    }
    
    // 验证价格是否为有效的正数
    const priceNum = parseFloat(formData.price)
    if (isNaN(priceNum) || priceNum <= 0) {
      wx.showToast({
        title: '请输入有效的拼车费用',
        icon: 'none'
      })
      return
    }
    
    // 验证价格不能超过999
    if (priceNum > 999) {
      wx.showToast({
        title: '拼车费用不能超过999',
        icon: 'none'
      })
      return
    }
    
    if (!formData.wechat) {
      wx.showToast({
        title: '请输入微信',
        icon: 'none'
      })
      return
    }
    
    // 如果填写了电话，必须至少11位
    if (formData.phone && formData.phone.length > 0 && formData.phone.length < 11) {
      wx.showToast({
        title: '手机号不能少于11位',
        icon: 'none'
      })
      return
    }

    // 在提交前进行登录校验
    const that = this
    
    // 点击提交时缓存表单数据（无论是否登录）
    this.cacheFormData()
    
    util.executeWithLoginCheck(
      () => {
        // 用户已登录，执行提交
        if (that.data.isEditMode) {
          that.updateCarpool(formData)
        } else {
          that.addCarpool(formData)
        }
      },
      "发布拼车信息需要先登录，是否立即登录？",
      "/pages/carpoolAdd/carpoolAdd"
    )
  },

  /**
   * 缓存表单数据
   */
  cacheFormData: function() {
    const cacheKey = 'carpoolAdd_formData_cache'
    const formData = JSON.parse(JSON.stringify(this.data.formData))
    wx.setStorageSync(cacheKey, formData)
    console.log('已缓存拼车表单数据:', formData)
  },

  /**
   * 恢复缓存的表单数据
   */
  restoreFormData: function() {
    const cacheKey = 'carpoolAdd_formData_cache'
    const cachedData = wx.getStorageSync(cacheKey)
    
    if (cachedData) {
      console.log('恢复缓存的拼车表单数据:', cachedData)
      this.setData({
        formData: cachedData
      })
      // 恢复后清除缓存
      wx.removeStorageSync(cacheKey)
    }
  },

  /**
   * 更新拼车接口调用
   */
  updateCarpool: function(formData) {
    const api = require('../../config/api.js')
    const util = require('../../utils/util.js')
    
    const updateData = {
      id: this.data.editId,
      bag: formData.bag,
      date: formData.date,
      goTime: formData.goTime,
      detail: formData.detail,
      fromAddr: formData.fromAddr,
      people: formData.people,
      phone: formData.phone,
      price: formData.price,
      side: formData.side,
      ski: formData.ski,
      toAddr: formData.toAddr,
      type: formData.type,
      wechat: formData.wechat
    }
    
    // 根据side的值决定传递哪个id和地图选点信息
    // side=0 (前往): 出发地点用地图，到达地点用雪场
    // side=1 (返回): 出发地点用雪场，到达地点用地图
    if (formData.side === 0) {
      // 前往雪场，出发地点用地图，到达地点是雪场
      if (formData.toAddrId) {
        updateData.toAddrId = formData.toAddrId
      }
      // 出发地点使用地图选点，提交 longitude、latitude、locationName
      if (formData.fromLongitude !== null && formData.fromLongitude !== undefined) {
        updateData.longitude = formData.fromLongitude
      }
      if (formData.fromLatitude !== null && formData.fromLatitude !== undefined) {
        updateData.latitude = formData.fromLatitude
      }
      if (formData.fromLocationName) {
        updateData.locationName = formData.fromLocationName
      }
    } else {
      // 返回，出发地点是雪场，到达地点用地图
      if (formData.fromAddrId) {
        updateData.fromAddrId = formData.fromAddrId
      }
      // 到达地点使用地图选点，提交 longitude、latitude、locationName
      if (formData.toLongitude !== null && formData.toLongitude !== undefined) {
        updateData.longitude = formData.toLongitude
      }
      if (formData.toLatitude !== null && formData.toLatitude !== undefined) {
        updateData.latitude = formData.toLatitude
      }
      if (formData.toLocationName) {
        updateData.locationName = formData.toLocationName
      }
    }
    
    // 转换价格为数字类型（如果后端需要数字类型）
    if (updateData.price) {
      updateData.price = parseFloat(updateData.price)
    }
    // 转换电话号码为数字类型（如果后端需要数字类型）
    if (updateData.phone) {
      updateData.phone = parseFloat(updateData.phone)
    }
    
    console.log('调用编辑拼车接口，参数:', updateData)
    console.log('接口地址:', api.CarEdit)
    
    util.request(api.CarEdit, updateData, 'POST', 'application/json').then(res => {
      console.log('更新拼车响应:', res)
      
      const normalizedRes = util.normalizeApiResponse(res)
      console.log('标准化后的响应:', normalizedRes)
      
      if (normalizedRes.success) {
        // 更新成功后清除缓存数据
        const cacheKey = 'carpoolAdd_formData_cache'
        wx.removeStorageSync(cacheKey)
        console.log('更新成功，已清除缓存的表单数据')
        
        wx.showToast({
          title: '更新成功',
          icon: 'success'
        })
        setTimeout(() => {
          wx.navigateBack()
        }, 1500)
      } else {
        wx.showToast({
          title: normalizedRes.message || '更新失败',
          icon: 'none',
          duration: 2000
        })
      }
    }).catch(err => {
      console.error('更新拼车失败:', err)
      wx.showToast({
        title: '网络错误，请重试',
        icon: 'none'
      })
    })
  },

  /**
   * 发布拼车接口调用
   */
  addCarpool: function(formData) {
    const api = require('../../config/api.js')
    const util = require('../../utils/util.js')
    
    // 构建请求数据
    const requestData = {
      bag: formData.bag,
      date: formData.date,
      goTime: formData.goTime,
      detail: formData.detail,
      fromAddr: formData.fromAddr,
      people: formData.people,
      phone: formData.phone,
      price: formData.price,
      side: formData.side,
      ski: formData.ski,
      toAddr: formData.toAddr,
      type: formData.type,
      wechat: formData.wechat
    }
    
    // 根据side的值决定传递哪个id和地图选点信息
    // side=0 (前往): 出发地点用地图，到达地点用雪场
    // side=1 (返回): 出发地点用雪场，到达地点用地图
    if (formData.side === 0) {
      // 前往雪场，出发地点用地图，到达地点是雪场
      if (formData.toAddrId) {
        requestData.toAddrId = formData.toAddrId
      }
      // 出发地点使用地图选点，提交 longitude、latitude、locationName
      if (formData.fromLongitude !== null && formData.fromLongitude !== undefined) {
        requestData.longitude = formData.fromLongitude
      }
      if (formData.fromLatitude !== null && formData.fromLatitude !== undefined) {
        requestData.latitude = formData.fromLatitude
      }
      if (formData.fromLocationName) {
        requestData.locationName = formData.fromLocationName
      }
    } else {
      // 返回，出发地点是雪场，到达地点用地图
      if (formData.fromAddrId) {
        requestData.fromAddrId = formData.fromAddrId
      }
      // 到达地点使用地图选点，提交 longitude、latitude、locationName
      if (formData.toLongitude !== null && formData.toLongitude !== undefined) {
        requestData.longitude = formData.toLongitude
      }
      if (formData.toLatitude !== null && formData.toLatitude !== undefined) {
        requestData.latitude = formData.toLatitude
      }
      if (formData.toLocationName) {
        requestData.locationName = formData.toLocationName
      }
    }
    
    util.request(api.CarAdd, requestData, 'POST', 'application/json').then(res => {
      console.log('发布拼车响应:', res)
      
      // 使用标准化的响应处理
      const normalizedRes = util.normalizeApiResponse(res)
      console.log('标准化后的响应:', normalizedRes)
      
      if (normalizedRes.success) {
        // 提交成功后清除缓存数据
        const cacheKey = 'carpoolAdd_formData_cache'
        wx.removeStorageSync(cacheKey)
        console.log('提交成功，已清除缓存的表单数据')
        
        const publishedId = normalizedRes.data?.id || normalizedRes.data || null;
        // 显示成功弹窗，保存返回的ID
        this.setData({
          showSuccessPopup: true,
          publishedId: publishedId
        });
      } else {
        wx.showToast({
          title: normalizedRes.message || '发布失败',
          icon: 'none'
        })
      }
    }).catch(err => {
      console.error('发布拼车失败:', err)
      wx.showToast({
        title: '网络错误，请重试',
        icon: 'none'
      })
    })
  },

  /**
   * 关闭成功弹窗
   */
  closeSuccessPopup: function() {
    this.setData({
      showSuccessPopup: false
    })
    // 返回上一层页面
    setTimeout(() => {
      wx.navigateBack()
    }, 300)
  },

  /**
   * 阻止事件冒泡
   */
  stopPropagation: function() {
    // 阻止事件冒泡，防止点击弹窗内容时关闭弹窗
  },

  /**
   * 生成分享卡片（预生成并缓存）
   */
  generateShareCard: function(publishedId) {
    const that = this;
    
    if (!publishedId) {
      return Promise.resolve();
    }
    
    // 获取详情数据
    return util
      .request(api.CarInfo, { id: publishedId }, "POST", "application/json")
      .then((res) => {
        const normalizedRes = util.normalizeApiResponse(res);

        if (normalizedRes.success && normalizedRes.data) {
          const carInfo = normalizedRes.data;

          // 格式化时间戳为可读日期
          const formatDate = (timestamp, goTime) => {
            if (!timestamp) return '';
            
            try {
              // 判断是秒级时间戳还是毫秒级时间戳，或者是日期字符串
              let date;
              if (typeof timestamp === 'string') {
                // 如果是日期字符串，如 "2024-01-01"
                date = new Date(timestamp);
              } else {
                date = timestamp < 10000000000 ? new Date(timestamp * 1000) : new Date(timestamp);
              }
              
              // 验证日期是否有效
              if (isNaN(date.getTime())) {
                return '';
              }
              
              const now = new Date();
              const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
              const tomorrow = new Date(today.getTime() + 24 * 60 * 60 * 1000);
              const dayAfterTomorrow = new Date(today.getTime() + 2 * 24 * 60 * 60 * 1000);
              
              const targetDate = new Date(date.getFullYear(), date.getMonth(), date.getDate());
              
              let prefix = '';
             
              const month = date.getMonth() + 1;
              const day = date.getDate();
              const dayNames = ['周日', '周一', '周二', '周三', '周四', '周五', '周六'];
              const dayName = dayNames[date.getDay()];
              // 如果有goTime，使用goTime；否则不显示时间
              if (goTime) {
                return `${month}.${day} ${dayName} ${goTime}`;
              }
              return `${month}.${day} ${dayName}`;
            } catch (error) {
              console.error('格式化日期失败:', error);
              return '';
            }
          };

          // 格式化时间
          const formattedDate = formatDate(carInfo.date, carInfo.goTime);
          const timeText = formattedDate || (carInfo.goTime || '');

          // 构建tripInfo数据
          const tripInfo = {
            serviceType: carInfo.type === 0 ? "车找人" : "人找车",
            time: timeText,
            departure: carInfo.fromAddr || "",
            destination: carInfo.toAddr || ""
          };

          // 异步生成分享卡片
          return shareCard
            .getShareCard("carpool", {
              id: publishedId,
              carpoolId: publishedId,
              tripInfo: tripInfo
            })
            .then((shareConfig) => {
              // 缓存分享卡片图片路径
              that.setData({
                shareCardImageUrl: shareConfig.imageUrl
              });
              // 返回分享配置，供调用方使用
              return shareConfig;
            })
            .catch((err) => {
              console.error("生成分享卡片失败:", err);
              // 失败时使用基础图
              const fallbackConfig = {
                imageUrl: "/static/images/shareBase.png"
              };
              that.setData({
                shareCardImageUrl: fallbackConfig.imageUrl
              });
              return fallbackConfig;
            });
        } else {
          // 如果获取详情数据失败，返回基础图配置
          const fallbackConfig = {
            imageUrl: "/static/images/shareBase.png"
          };
          that.setData({
            shareCardImageUrl: fallbackConfig.imageUrl
          });
          return Promise.resolve(fallbackConfig);
        }
      })
      .catch((err) => {
        console.error("获取详情数据失败:", err);
        // 返回基础图配置
        const fallbackConfig = {
          imageUrl: "/static/images/shareBase.png"
        };
        that.setData({
          shareCardImageUrl: fallbackConfig.imageUrl
        });
        return Promise.resolve(fallbackConfig);
      });
  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage: async function () {
    const { publishedId, shareCardImageUrl } = this.data;
    
    if (!publishedId) {
      return {
        title: "滑雪去小程序",
        path: "/pages/index/index",
        imageUrl: "/static/images/shareBase.png"
      };
    }
    
    // 获取分享配置
    const shareConfig = shareCard.getShareConfig('carpool', {
      id: publishedId,
      carpoolId: publishedId,
      tripInfo: {}
    });
    
    // 如果没有缓存的分享卡片，显示loading并同步等待生成完成
    if (!shareCardImageUrl) {
      wx.showLoading({
        title: '生成分享卡片中...',
        mask: true
      });
      try {
        // 同步等待分享卡片生成完成，并获取返回的分享配置
        const generatedConfig = await this.generateShareCard(publishedId);
        // 使用生成的分享卡片图片
        shareConfig.imageUrl = generatedConfig?.imageUrl || '/static/images/shareBase.png';
      } catch (err) {
        console.error('生成分享卡片失败:', err);
        shareConfig.imageUrl = '/static/images/shareBase.png';
      } finally {
        wx.hideLoading();
      }
    } else {
      // 使用缓存的分享卡片图片
      shareConfig.imageUrl = shareCardImageUrl;
    }
    
    return shareConfig;
  },

  /**
   * 处理查看
   */
  handleView: function() {
    const { publishedId } = this.data;
    
    // 关闭弹窗
    this.setData({
      showSuccessPopup: false
    });
    
    setTimeout(() => {
      if (publishedId) {
        // 跳转到详情页
        wx.redirectTo({
          url: `/pages/carpoolDetail/carpoolDetail?id=${publishedId}`,
          fail: (err) => {
            console.error('跳转失败:', err);
            wx.navigateBack();
          }
        });
      } else {
        // 如果没有ID，返回上一页
        wx.navigateBack();
      }
    }, 300);
  },

  /**
   * 加入俱乐部
   */
  joinClub: function() {
    console.log('点击加入俱乐部');
    
    // 引入工具函数
    const util = require('../../utils/util.js');
    
    // 关闭成功弹窗
    this.setData({
      showSuccessPopup: false
    });
    
    // 使用工具函数进行登录校验
    util.executeWithLoginCheck(
      () => {
        // 用户已登录，跳转到加入俱乐部页面
        wx.navigateTo({
          url: '/pages/clubJoin/clubJoin',
          success: function() {
            console.log('跳转到加入俱乐部页面成功');
          },
          fail: function(err) {
            console.error('跳转到加入俱乐部页面失败:', err);
            wx.showToast({
              title: '页面跳转失败',
              icon: 'none',
              duration: 2000
            });
          }
        });
      },
      '加入俱乐部需要先登录，是否立即登录？',
      '/pages/carpoolAdd/carpoolAdd'
    );
  },

  /**
   * 重置表单
   */
  onReset: function() {
    this.setData({
      formData: {
        date: '',
        goTime: '',
        fromAddr: '',
        toAddr: '',
        fromAddrId: '',
        toAddrId: '',
        fromLongitude: null,
        fromLatitude: null,
        fromLocationName: '',
        toLongitude: null,
        toLatitude: null,
        toLocationName: '',
        people: 0,
        ski: 0,
        bag: 0,
        price: '',
        detail: '',
        wechat: '',
        phone: '',
        side: 0,
        type: 0
      },
      showDatePicker: false,
      showSuccessPopup: false
    })
    
    wx.showToast({
      title: '已重置',
      icon: 'success'
    })
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady: function () {
    console.log('拼车信息新增页面渲染完成')
  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow: function () {
    console.log('拼车信息新增页面显示')
    // 重新加载用户信息，以便更新俱乐部状态
    this.loadUserInfo()
    
    // 编辑模式下不恢复缓存，因为编辑模式应该显示从服务器加载的数据
    if (this.data.isEditMode) {
      return
    }
    
    // 检查是否有缓存的表单数据（从登录页面返回时恢复）
    const userInfo = wx.getStorageSync('userInfo')
    const token = wx.getStorageSync('token')
    const navUrl = wx.getStorageSync('navUrl')
    
    // 如果用户已登录，检查并恢复缓存的表单数据
    if (userInfo && token) {
      // 如果 navUrl 匹配，清除导航URL
      if (navUrl === '/pages/carpoolAdd/carpoolAdd') {
        wx.removeStorageSync('navUrl')
      }
      // 无论 navUrl 是否匹配，都尝试恢复缓存（防止 navUrl 未设置的情况）
      this.restoreFormData()
    }
  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide: function () {
    console.log('拼车信息新增页面隐藏')
  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload: function () {
    console.log('拼车信息新增页面卸载')
  },

  /**
   * 页面相关事件处理函数--监听页面滚动
   */
  onPageScroll: function () {
    // 页面滚动时关闭雪场选择下拉组件
    if (this.data.skiDropdownOpen) {
      this.setData({
        skiDropdownOpen: false
      })
    }
  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh: function () {
    console.log('用户下拉刷新')
    wx.stopPullDownRefresh()
  },

})
